package com.cencat.order.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.cencat.order.dto.DispatchDTO;
import com.cencat.order.entity.Dispatch;
import com.cencat.order.vo.DispatchVO;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

/**
 * 智能派单业务逻辑接口
 * 
 * @author cencat
 * @date 2024-01-20
 */
public interface DispatchService extends IService<Dispatch> {

    /**
     * 分页查询派单列表
     *
     * @param page 分页参数
     * @param dispatchCode 派单编号(模糊查询)
     * @param orderId 订单ID
     * @param routeId 路线ID
     * @param driverId 司机ID
     * @param vehicleId 车辆ID
     * @param merchantId 商家ID
     * @param dispatchType 派单类型
     * @param dispatchMethod 派单方式
     * @param dispatchStatus 派单状态
     * @param priority 优先级
     * @param urgencyLevel 紧急程度
     * @param startTime 创建开始时间
     * @param endTime 创建结束时间
     * @return 派单分页列表
     */
    IPage<DispatchVO> getDispatchPage(Page<DispatchVO> page,
                                     String dispatchCode,
                                     Long orderId,
                                     Long routeId,
                                     Long driverId,
                                     Long vehicleId,
                                     Long merchantId,
                                     String dispatchType,
                                     String dispatchMethod,
                                     Integer dispatchStatus,
                                     Integer priority,
                                     Integer urgencyLevel,
                                     LocalDateTime startTime,
                                     LocalDateTime endTime);

    /**
     * 根据派单编号查询派单信息
     *
     * @param dispatchCode 派单编号
     * @return 派单信息
     */
    DispatchVO getByDispatchCode(String dispatchCode);

    /**
     * 根据订单ID查询派单信息
     *
     * @param orderId 订单ID
     * @return 派单信息
     */
    DispatchVO getByOrderId(Long orderId);

    /**
     * 根据司机ID查询派单列表
     *
     * @param driverId 司机ID
     * @param dispatchStatus 派单状态
     * @param startTime 查询开始时间
     * @param endTime 查询结束时间
     * @return 派单列表
     */
    List<DispatchVO> getByDriverId(Long driverId,
                                  Integer dispatchStatus,
                                  LocalDateTime startTime,
                                  LocalDateTime endTime);

    /**
     * 根据车辆ID查询派单列表
     *
     * @param vehicleId 车辆ID
     * @param dispatchStatus 派单状态
     * @param startTime 查询开始时间
     * @param endTime 查询结束时间
     * @return 派单列表
     */
    List<DispatchVO> getByVehicleId(Long vehicleId,
                                   Integer dispatchStatus,
                                   LocalDateTime startTime,
                                   LocalDateTime endTime);

    /**
     * 根据商家ID查询派单列表
     *
     * @param merchantId 商家ID
     * @param dispatchStatus 派单状态
     * @param startTime 查询开始时间
     * @param endTime 查询结束时间
     * @return 派单列表
     */
    List<DispatchVO> getByMerchantId(Long merchantId,
                                    Integer dispatchStatus,
                                    LocalDateTime startTime,
                                    LocalDateTime endTime);

    /**
     * 查询派单统计信息
     *
     * @param driverId 司机ID
     * @param vehicleId 车辆ID
     * @param merchantId 商家ID
     * @param startTime 统计开始时间
     * @param endTime 统计结束时间
     * @return 统计信息
     */
    Map<String, Object> getDispatchStatistics(Long driverId,
                                             Long vehicleId,
                                             Long merchantId,
                                             LocalDateTime startTime,
                                             LocalDateTime endTime);

    /**
     * 创建派单信息
     *
     * @param dispatchDTO 派单数据传输对象
     * @return 创建结果
     */
    boolean createDispatch(DispatchDTO dispatchDTO);

    /**
     * 更新派单信息
     *
     * @param dispatchId 派单ID
     * @param dispatchDTO 派单数据传输对象
     * @return 更新结果
     */
    boolean updateDispatch(Long dispatchId, DispatchDTO dispatchDTO);

    /**
     * 智能派单算法
     *
     * @param orderId 订单ID
     * @param dispatchRules 派单规则
     * @param algorithmVersion 算法版本
     * @return 派单结果
     */
    Map<String, Object> intelligentDispatch(Long orderId,
                                           Map<String, Object> dispatchRules,
                                           String algorithmVersion);

    /**
     * 手动派单
     *
     * @param orderId 订单ID
     * @param driverId 司机ID
     * @param vehicleId 车辆ID
     * @param routeId 路线ID
     * @param dispatchReason 派单原因
     * @return 派单结果
     */
    boolean manualDispatch(Long orderId,
                          Long driverId,
                          Long vehicleId,
                          Long routeId,
                          String dispatchReason);

    /**
     * 批量派单
     *
     * @param orderIds 订单ID列表
     * @param dispatchRules 派单规则
     * @param batchSize 批次大小
     * @return 批量派单结果
     */
    Map<String, Object> batchDispatch(List<Long> orderIds,
                                     Map<String, Object> dispatchRules,
                                     Integer batchSize);

    /**
     * 重新派单
     *
     * @param dispatchId 原派单ID
     * @param redispatchReason 重新派单原因
     * @param newDispatchRules 新派单规则
     * @return 重新派单结果
     */
    boolean redispatch(Long dispatchId,
                      String redispatchReason,
                      Map<String, Object> newDispatchRules);

    /**
     * 取消派单
     *
     * @param dispatchId 派单ID
     * @param cancelReason 取消原因
     * @return 取消结果
     */
    boolean cancelDispatch(Long dispatchId, String cancelReason);

    /**
     * 司机接受派单
     *
     * @param dispatchId 派单ID
     * @param driverId 司机ID
     * @param acceptTime 接受时间
     * @return 接受结果
     */
    boolean acceptDispatch(Long dispatchId,
                          Long driverId,
                          LocalDateTime acceptTime);

    /**
     * 司机拒绝派单
     *
     * @param dispatchId 派单ID
     * @param driverId 司机ID
     * @param rejectReason 拒绝原因
     * @param rejectTime 拒绝时间
     * @return 拒绝结果
     */
    boolean rejectDispatch(Long dispatchId,
                          Long driverId,
                          String rejectReason,
                          LocalDateTime rejectTime);

    /**
     * 派单超时处理
     *
     * @param dispatchId 派单ID
     * @param timeoutType 超时类型
     * @param timeoutAction 超时处理动作
     * @return 处理结果
     */
    boolean handleDispatchTimeout(Long dispatchId,
                                 String timeoutType,
                                 String timeoutAction);

    /**
     * 派单异常处理
     *
     * @param dispatchId 派单ID
     * @param exceptionType 异常类型
     * @param exceptionDescription 异常描述
     * @param handlingAction 处理动作
     * @return 处理结果
     */
    boolean handleDispatchException(Long dispatchId,
                                   String exceptionType,
                                   String exceptionDescription,
                                   String handlingAction);

    /**
     * 更新派单状态
     *
     * @param dispatchId 派单ID
     * @param dispatchStatus 派单状态
     * @param statusRemark 状态备注
     * @return 更新结果
     */
    boolean updateDispatchStatus(Long dispatchId,
                                Integer dispatchStatus,
                                String statusRemark);

    /**
     * 更新派单司机信息
     *
     * @param dispatchId 派单ID
     * @param driverId 司机ID
     * @param driverName 司机姓名
     * @param driverPhone 司机电话
     * @return 更新结果
     */
    boolean updateDispatchDriverInfo(Long dispatchId,
                                    Long driverId,
                                    String driverName,
                                    String driverPhone);

    /**
     * 更新派单匹配得分
     *
     * @param dispatchId 派单ID
     * @param matchingScore 匹配得分
     * @param scoreDetails 得分详情
     * @return 更新结果
     */
    boolean updateMatchingScore(Long dispatchId,
                               BigDecimal matchingScore,
                               String scoreDetails);

    /**
     * 更新派单时间信息
     *
     * @param dispatchId 派单ID
     * @param estimatedPickupTime 预计取货时间
     * @param estimatedDeliveryTime 预计配送时间
     * @param actualPickupTime 实际取货时间
     * @param actualDeliveryTime 实际配送时间
     * @return 更新结果
     */
    boolean updateDispatchTimeInfo(Long dispatchId,
                                  LocalDateTime estimatedPickupTime,
                                  LocalDateTime estimatedDeliveryTime,
                                  LocalDateTime actualPickupTime,
                                  LocalDateTime actualDeliveryTime);

    /**
     * 更新派单费用信息
     *
     * @param dispatchId 派单ID
     * @param estimatedCost 预计费用
     * @param actualCost 实际费用
     * @param fuelCost 燃油费用
     * @param tollCost 过路费
     * @param laborCost 人工费用
     * @param otherCost 其他费用
     * @return 更新结果
     */
    boolean updateDispatchCostInfo(Long dispatchId,
                                  BigDecimal estimatedCost,
                                  BigDecimal actualCost,
                                  BigDecimal fuelCost,
                                  BigDecimal tollCost,
                                  BigDecimal laborCost,
                                  BigDecimal otherCost);

    /**
     * 更新派单评价信息
     *
     * @param dispatchId 派单ID
     * @param customerRating 客户评分
     * @param customerFeedback 客户反馈
     * @param driverRating 司机评分
     * @param driverFeedback 司机反馈
     * @param systemRating 系统评分
     * @return 更新结果
     */
    boolean updateDispatchRatingInfo(Long dispatchId,
                                    BigDecimal customerRating,
                                    String customerFeedback,
                                    BigDecimal driverRating,
                                    String driverFeedback,
                                    BigDecimal systemRating);

    /**
     * 批量更新派单状态
     *
     * @param dispatchIds 派单ID列表
     * @param dispatchStatus 派单状态
     * @return 更新结果
     */
    boolean batchUpdateDispatchStatus(List<Long> dispatchIds, Integer dispatchStatus);

    /**
     * 查找候选司机
     *
     * @param orderId 订单ID
     * @param searchRadius 搜索半径
     * @param vehicleTypeRequirement 车辆类型要求
     * @param loadCapacityRequirement 载重要求
     * @param timeConstraints 时间约束
     * @return 候选司机列表
     */
    List<Map<String, Object>> findCandidateDrivers(Long orderId,
                                                  BigDecimal searchRadius,
                                                  String vehicleTypeRequirement,
                                                  BigDecimal loadCapacityRequirement,
                                                  Map<String, Object> timeConstraints);

    /**
     * 司机匹配度计算
     *
     * @param orderId 订单ID
     * @param driverId 司机ID
     * @param matchingCriteria 匹配标准
     * @return 匹配度得分
     */
    BigDecimal calculateDriverMatchingScore(Long orderId,
                                           Long driverId,
                                           Map<String, Object> matchingCriteria);

    /**
     * 派单效率分析
     *
     * @param startTime 分析开始时间
     * @param endTime 分析结束时间
     * @param dispatchType 派单类型
     * @param algorithmVersion 算法版本
     * @return 效率分析结果
     */
    Map<String, Object> analyzeDispatchEfficiency(LocalDateTime startTime,
                                                  LocalDateTime endTime,
                                                  String dispatchType,
                                                  String algorithmVersion);

    /**
     * 派单成功率统计
     *
     * @param startTime 统计开始时间
     * @param endTime 统计结束时间
     * @param groupBy 分组方式(司机/车辆/商家/时间段)
     * @return 成功率统计结果
     */
    Map<String, Object> getDispatchSuccessRateStatistics(LocalDateTime startTime,
                                                         LocalDateTime endTime,
                                                         String groupBy);

    /**
     * 派单时效性分析
     *
     * @param startTime 分析开始时间
     * @param endTime 分析结束时间
     * @param dispatchMethod 派单方式
     * @return 时效性分析结果
     */
    Map<String, Object> analyzeDispatchTimeliness(LocalDateTime startTime,
                                                  LocalDateTime endTime,
                                                  String dispatchMethod);

    /**
     * 派单成本效益分析
     *
     * @param startTime 分析开始时间
     * @param endTime 分析结束时间
     * @param costFactors 成本因素
     * @return 成本效益分析结果
     */
    Map<String, Object> analyzeCostBenefit(LocalDateTime startTime,
                                          LocalDateTime endTime,
                                          List<String> costFactors);

    /**
     * 派单质量评估
     *
     * @param dispatchId 派单ID
     * @param qualityMetrics 质量指标
     * @return 质量评估结果
     */
    Map<String, Object> evaluateDispatchQuality(Long dispatchId,
                                               List<String> qualityMetrics);

    /**
     * 派单优化建议
     *
     * @param dispatchId 派单ID
     * @param optimizationGoals 优化目标
     * @return 优化建议
     */
    List<Map<String, Object>> getDispatchOptimizationSuggestions(Long dispatchId,
                                                                List<String> optimizationGoals);

    /**
     * 派单预测分析
     *
     * @param predictionPeriod 预测周期
     * @param historicalData 历史数据范围
     * @param predictionFactors 预测因素
     * @return 预测分析结果
     */
    Map<String, Object> predictDispatchDemand(String predictionPeriod,
                                             Map<String, LocalDateTime> historicalData,
                                             List<String> predictionFactors);

    /**
     * 派单热力图数据
     *
     * @param startTime 统计开始时间
     * @param endTime 统计结束时间
     * @param regionLevel 区域级别(省/市/区)
     * @param metricType 指标类型
     * @return 热力图数据
     */
    List<Map<String, Object>> getDispatchHeatmapData(LocalDateTime startTime,
                                                     LocalDateTime endTime,
                                                     String regionLevel,
                                                     String metricType);

    /**
     * 派单实时监控
     *
     * @param monitoringScope 监控范围
     * @param alertThresholds 告警阈值
     * @return 实时监控数据
     */
    Map<String, Object> getDispatchRealTimeMonitoring(Map<String, Object> monitoringScope,
                                                      Map<String, Object> alertThresholds);

    /**
     * 派单异常检测
     *
     * @param detectionPeriod 检测周期
     * @param anomalyTypes 异常类型
     * @return 异常检测结果
     */
    List<Map<String, Object>> detectDispatchAnomalies(Map<String, LocalDateTime> detectionPeriod,
                                                      List<String> anomalyTypes);

    /**
     * 派单规则引擎
     *
     * @param orderId 订单ID
     * @param ruleSet 规则集
     * @param ruleContext 规则上下文
     * @return 规则执行结果
     */
    Map<String, Object> executeDispatchRules(Long orderId,
                                            String ruleSet,
                                            Map<String, Object> ruleContext);

    /**
     * 派单A/B测试
     *
     * @param testConfig 测试配置
     * @param testPeriod 测试周期
     * @param testMetrics 测试指标
     * @return A/B测试结果
     */
    Map<String, Object> runDispatchABTest(Map<String, Object> testConfig,
                                         Map<String, LocalDateTime> testPeriod,
                                         List<String> testMetrics);

    /**
     * 派单机器学习模型训练
     *
     * @param trainingData 训练数据范围
     * @param modelType 模型类型
     * @param trainingParameters 训练参数
     * @return 模型训练结果
     */
    Map<String, Object> trainDispatchMLModel(Map<String, LocalDateTime> trainingData,
                                            String modelType,
                                            Map<String, Object> trainingParameters);

    /**
     * 派单智能推荐
     *
     * @param orderId 订单ID
     * @param recommendationType 推荐类型
     * @param recommendationCount 推荐数量
     * @return 智能推荐结果
     */
    List<Map<String, Object>> getIntelligentDispatchRecommendations(Long orderId,
                                                                   String recommendationType,
                                                                   Integer recommendationCount);

    /**
     * 软删除派单信息
     *
     * @param dispatchId 派单ID
     * @return 删除结果
     */
    boolean softDeleteDispatch(Long dispatchId);

    /**
     * 批量软删除派单信息
     *
     * @param dispatchIds 派单ID列表
     * @return 删除结果
     */
    boolean batchSoftDeleteDispatches(List<Long> dispatchIds);

    /**
     * 恢复已删除的派单信息
     *
     * @param dispatchId 派单ID
     * @return 恢复结果
     */
    boolean restoreDispatch(Long dispatchId);

    /**
     * 查询派单操作日志
     *
     * @param dispatchId 派单ID
     * @param startTime 查询开始时间
     * @param endTime 查询结束时间
     * @param limit 查询数量限制
     * @return 操作日志列表
     */
    List<Map<String, Object>> getDispatchOperationLogs(Long dispatchId,
                                                       LocalDateTime startTime,
                                                       LocalDateTime endTime,
                                                       Integer limit);
}